package com.ddm.service.impl.webImpl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ddm.entity.webEntity.Technique;
import com.ddm.mapper.TechniqueMapper;
import com.ddm.service.webService.TechniqueService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class TechniqueServiceImpl extends ServiceImpl<TechniqueMapper, Technique> implements TechniqueService {

    @Autowired
    private TechniqueMapper techniqueMapper;

    @Override
    public Boolean add(Technique technique) {
        if (technique == null) {
            return false;
        }
        // 检查技术名称
        if (technique.getName() == null || technique.getName().trim().isEmpty()) {
            return false;
        }
        // 检查发布日期
        if (technique.getPublishDate() == null) {
            return false;
        }
        // 检查发布者
        if (technique.getPublisher() == null || technique.getPublisher().trim().isEmpty()) {
            return false;
        }
        // 检查技术类型
        if (technique.getType() == null || technique.getType().trim().isEmpty()) {
            return false;
        }
        // 检查技术内容
        if (technique.getContent() == null || technique.getContent().trim().isEmpty()) {
            return false;
        }
        // 检查技术图片
        if (technique.getImg() == null || technique.getImg().trim().isEmpty()) {
            return false;
        }
        // 检查技术视频
        if (technique.getVideo() == null || technique.getVideo().trim().isEmpty()) {
            return false;
        }
        return save(technique);
    }


    @Override
    public Boolean update(Technique technique) {
        if (technique == null || technique.getId() == null) {
            return false;
        }
        return updateById(technique);
    }

//    @Override
//    public Boolean update(Technique technique) {
//        if (technique == null || technique.getId() == null) {
//            return false;
//        }
//        //记录受影响的列数
//        int rows = 0;
//        UpdateWrapper<Technique> wrapper = new UpdateWrapper<>();
//        wrapper.eq("id", technique.getId());
//
//        // 设置要更新的字段，忽略null值
//        LambdaUpdateWrapper<Technique> lambdaWrapper = wrapper.lambda();
//        if (technique.getName() != null) {
//            lambdaWrapper.set(Technique::getName, technique.getName());
//            rows++;
//        }
//        if (technique.getPublishDate() != null) {
//            lambdaWrapper.set(Technique::getPublishDate, technique.getPublishDate());
//            rows++;
//        }
//        if (technique.getPublisher() != null) {
//            lambdaWrapper.set(Technique::getPublisher, technique.getPublisher());
//            rows++;
//        }
//        if (technique.getType() != null) {
//            lambdaWrapper.set(Technique::getType, technique.getType());
//            rows++;
//        }
//        if (technique.getContent() != null) {
//            lambdaWrapper.set(Technique::getContent, technique.getContent());
//            rows++;
//        }
//        if (technique.getImg() != null) {
//            lambdaWrapper.set(Technique::getImg, technique.getImg());
//            rows++;
//        }
//        if (technique.getVideo() != null) {
//            lambdaWrapper.set(Technique::getVideo, technique.getVideo());
//            rows++;
//        }
//
//        update(technique);  // 执行保存
//        Technique updatedTechnique = getById(technique.getId());  // 通过ID查询数据
//        return updatedTechnique != null;  // 存在即返回true
//    }

    @Override
    public Boolean delete(Integer id) {
        if (id == null || id <= 0) {
            return false;
        }
        return removeById(id);
    }

    @Override
    public Technique getTechniqueById(Integer id) {
        return techniqueMapper.selectById(id);
    }

    @Override
    public List<Technique> getAllTechniques() {
        QueryWrapper<Technique> queryWrapper = new QueryWrapper<>();
        return techniqueMapper.selectList(queryWrapper);
    }



    @Override
    public IPage<Technique> getTechniquesByPage(Page<Technique> page, String key, String type) {
        QueryWrapper<Technique> wrapper = new QueryWrapper<>();
        LambdaQueryWrapper<Technique> lambdaWrapper = wrapper.lambda();

        // 处理多字段模糊查询（如果key不为空）
        if (key != null && !key.isEmpty()) {
            lambdaWrapper.nested(i -> i
                    .like(Technique::getName, key)
                    .or().like(Technique::getPublisher, key)
                    .or().like(Technique::getContent, key)
            );
        }

        // 处理type的精确匹配（无论key是否存在）
        if (type != null && !type.isEmpty()) {
            lambdaWrapper.eq(Technique::getType, type);
        }

        return this.page(page, lambdaWrapper);
    }



    @Override
    public IPage<Technique> getTechniqueByCategoryIds(List<Integer> ids, Page<Technique> page) {
        if (CollectionUtils.isEmpty(ids)) {
            return new Page<>(); // 返回空分页对象
        }
        // 创建查询条件
        QueryWrapper<Technique> wrapper = new QueryWrapper<>();
        wrapper.in("id", ids); // 查询ID在列表中的记录
        // 执行分页查询
        return techniqueMapper.selectPage(page, wrapper);
    }
}